Java8 之Stream 详解

一. 什么是Stream

​ Stream是数据渠道，是用于操作数据源（集合、数组等）所生成的元素序列。集合讲的是数据，流讲的是计算。

​ Stream有几个值得注意的地方：

​ ①:Stream自己不会存储元素

​ ②:Stream不会改变源对象。相反，它会返回一个持有结果的新Stream。

​ ③:Stream操作是延迟的，它会等到需要结果的时候才执行。

二. Stream操作三步骤

1. 创建Stream

​ 通过一个数据源(集合、数组)得到一个流

2. 中间操作

​ 一个中间操作链，对数据源的数据进行处理

3. 终止操作(终端操作)

​ 一个终止操作，执行中间操作链并产生结果

三. Stream 的创建

Stream的创建基本上可以说有四种方法：

1. 可以通过Collection系列集合提供的stream() 或者 parallelStream()

2. 通过Arrays中的静态方法stream()获取数组流

3. 通过Stream类中的静态of()方法

4. 创建无限流

   “`

     /**
     * 创建Stream
     */
    @Test
    public void test1(){
   
        //1. 可以通过Collection系列集合提供的stream() 或者 parallelStream()
   
        Stream<String> stream1 = list.stream();
   
        //2. 通过Arrays中的静态方法stream()获取数组流
        String[] strArray = new String[10];
        Stream<String> stream2 = Arrays.stream(strArray);
   
        //3. 通过Stream类中的静态of()方法
        Stream<String> stream3 =  Stream.of("aa","bb","cc");
   
        //4. 创建无限流
        //迭代
        Stream<Integer> stream4 = Stream.iterate(0,x -> x*2);
        //生成器
        Stream<Double> stream5 = Stream.generate(Math::random);
    }
   

   “`

四.Stream的中间操作

1.筛选与切片

​ ①：filter — 接收lambda，从流中排除某些元素

​ ②：limit — 截断流，使其元素不超过给定数量

​ ③：skip — 跳过元素，返回一个扔掉了前n个元素的流。若流中元素不足n个，则返回空流。

​ ④：distinct — 筛选，通过流所生成元素的hashCode()和equals()方法除重复元素

​

    /**
     * filter、limit、skip、distinct 等筛选及切片操作
     */
    @Test
    public void test2(){
        // 中间操作 不会执行任何操作
        Stream<Student> stream1 = studentList.stream()
                                            .filter(student -> student.getAge()>22);

        // 终止操作 一次性执行全部内容 即"惰性求值"
        stream1.forEach(System.out::println);
//        Student{id=12, name='lisi', age=23}
//        Student{id=13, name='wangwu', age=24}
//        Student{id=14, name='zhaoliu', age=25}

        studentList.stream()
                .filter(student -> student.getAge()>22)
                .limit(2)
                .forEach(System.out::println);
//        Student{id=12, name='lisi', age=23}
//        Student{id=13, name='wangwu', age=24}

        studentList.stream()
                .filter(student -> student.getAge()>22)
                .skip(2)
                .forEach(System.out::println);
//        Student{id=14, name='zhaoliu', age=25}

        List<String> strList =Arrays.asList("aa","bb","cc","aa");
        strList.stream().distinct().forEach(System.out::println);
//        aa
//        bb
//        cc
    }

2.映射

​ ①：map — 接收一个函数作为参数，该函数会作用到每个元素上，并将其映射成一个新元素

​ ②：flatMap — 接受一个函数作为参数，将流中的每个值都换成另一个流，然后把所有的流连接成一个流

​

     /**
     * map、flatMap等映射操作
     */
    @Test
    public void test3(){
        List<String> strList =Arrays.asList("aa","bb","cc","aa");
        strList.stream().map(String::toUpperCase).forEach(System.out::print);
        // AABBCCAA
        studentList.stream().map(Student::getName).forEach(System.out::print);
        // zhangsanlisiwangwuzhaoliu

        // TestStream1 是方法所在的类名
        Stream<Stream<Character>> stream = strList.stream().map(TestStream1::toCharacter);
        stream.forEach(stre ->{
            stre.forEach(System.out::print);
        });
        // aabbccaa
        strList.stream().flatMap(TestStream1::toCharacter).forEach(System.out::print);
        // aabbccaa  此方法相当于上述操作的简写
    }

    private static Stream<Character> toCharacter(String str){
        List<Character> list =new ArrayList<>();
        for(Character chr : str.toCharArray()){
            list.add(chr);
        }
        return list.stream();
    }

3.排序

​ ①：sorted() — 产生一个新流，其中按自然顺序排序

​ ②：sorted(Comparator com) — 产生一个新流，其中按比较器顺序排序

​

    /**
     * sorted
     */
    @Test
    public void test4(){
        List<String> strList =Arrays.asList("bb","cc","aa");
        strList.stream().sorted().forEach(System.out::println);
        // aa
        // bb
        // cc
        studentList.stream().sorted(Comparator.comparing(Student::getName))
                                .forEach(System.out::println);
        //Student{id=12, name='lisi', age=23}
        //Student{id=13, name='wangwu', age=24}
        //Student{id=11, name='zhangsan', age=22}
        //Student{id=14, name='zhaoliu', age=25}
    }

五. Stream的终止操作

1. 查找与匹配

​ ①：allMatch(Predicate p) — 检查是否匹配所有元素

​ ②：anyMatch(Predicate p) — 检查是否至少匹配一个元素

​ ③：noneMatch(Predicate p) — 检查是否没有匹配所有元素

​ ④：findFirst() — 返回第一个元素

​ ⑤：findAny() — 返回当前流中的任意元素

​ ⑥：count() — 返回流中元素总数

​ ⑦： max(Comparator c) — 返回流中最大值

​ ⑧：min(Comparator c) — 返回流中最小值

​ ⑨：forEach(Consumer c) — 内部迭代

    @Test
    public void test5() {
        // 所有学生的年龄都是22岁吗？
        boolean flag1 = studentList.stream().allMatch(s -> s.getAge() == 22);
        System.out.println(flag1); // false

        // 有学生的年龄是22岁吗
        boolean flag2 = studentList.stream().anyMatch(s -> s.getAge() ==22);
        System.out.println(flag2); // true

        // 是不是没有名字为tom的学生
        boolean flag3 = studentList.stream().noneMatch(s -> s.getName().equals("tom"));
        System.out.println(flag3); // true

        // 得到集合中的第一个元素
        Optional<Student> op1 = studentList.stream().findFirst();
        System.out.println(op1.get()); // Student{id=11, name='zhangsan', age=22}

        // 得到集合中任一元素
        Optional<Student> op2 = studentList.stream().findAny();
        System.out.println(op2.get()); // Student{id=11, name='zhangsan', age=22}

        // 一共有几个学生
        long count = studentList.stream().count();
        System.out.println(count);  // 4

        //得到年龄最大的学生信息
        Optional<Student> op3= studentList.stream().max(Comparator.comparing(Student::getAge));
        System.out.println(op3.get()); // Student{id=14, name='zhaoliu', age=25}

        //得到年龄最小的学生信息
        Optional<Student> op4= studentList.stream().min(Comparator.comparing(Student::getAge));
        System.out.println(op4.get());  // Student{id=11, name='zhangsan', age=22}
    }

2. 规约

​ ①：reduce(T identity, BinaryOperator accumulator) — identity为初始值，将流中元素反复结合起来，得到一个值。返回 T

​ ②：Optional reduce(BinaryOperator accumulator) — 将流中元素反复结合起来，得到一个值。
返回 Optional

    @Test
    public void test6(){
        // 第一个reduce方法第一个参数代表赋予结果一个初始值，说明没有空指针的危险 故直接返回基础类型
        int age1 = studentList.stream().map(Student::getAge).reduce(0,(x, y) -> x+y);
        System.out.println(age1); // 94
        // 第二个reduce方法没有初始值，为了避免空指针的危险，故返回 Optional 类型
        Optional<Integer> age2 = studentList.stream().map(Student::getAge).reduce((x, y) -> x+y);
        System.out.println(age2.get()); // 94
    }   

3. 收集

​ ①： toList — 把流中元素收集到List

​ ②： toSet — 把流中元素收集到Set

​ ③： toCollection — 把流中元素收集到创建的集合

​ ④： counting — 计算流中元素的个数

​ ⑤：summingInt — 对流中元素的整数属性求和

​ ⑥：averagingInt — 计算流中元素Integer属性的平均值

​ ⑦：maxBy — 根据比较器选择最大值

​ ⑧： minBy — 根据比较器选择最小值

​ ⑨：joining — 连接流中每个字符串

​ ⑩：groupingBy — 根据某属性值对流分组， 属性为K， 结果为Map

    @Test
    public void test7(){
        // toList
        List<String> list = studentList.stream().map(Student::getName)
                                       .collect(Collectors.toList());
        list.forEach(System.out::print); //  zhangsanlisiwangwuzhaoliu
        System.out.println("------------------------------------");
        // toSet
        Set<String> set = studentList.stream().map(Student::getName)
                                    .collect(Collectors.toSet());
        set.forEach(System.out::print); // lisizhaoliuzhangsanwangwu
        System.out.println("------------------------------------");
        // toCollection
        HashSet<String> hashSet = studentList.stream().map(Student::getName)
                            .collect(Collectors.toCollection(HashSet::new));
        hashSet.forEach(System.out::print); // lisizhaoliuzhangsanwangwu
    }

    @Test
    public void test8(){
        // 总数
        long count = studentList.stream().collect(Collectors.counting());
        System.out.println(count);  // 4

        // 平均值
        double ave = studentList.stream().collect(Collectors.averagingInt(Student::getAge));
        System.out.println(ave);  // 23.5

        //总和
        int sum = studentList.stream().collect(Collectors.summingInt(Student::getAge));
        System.out.println(sum);  // 94

        //最大值
        Optional<Integer> max = studentList.stream().map(Student::getAge)
                                        .collect(Collectors.maxBy(Integer::compare));
        System.out.println(max.get());  // 25

        // 最小值
        Optional<Integer> min = studentList.stream().map(Student::getAge)
                .collect(Collectors.minBy(Integer::compare));
        System.out.println(min.get());  // 22

        // 分组
        Map<Integer,List<Student>> map = studentList.stream().collect(Collectors.
                                        groupingBy(Student::getAge));
        System.out.println(map);
        // {22=[Student{id=11, name='zhangsan', age=22}, Student{id=15, name='liuqi', age=22}],
        // 23=[Student{id=12, name='lisi', age=23}],
        // 24=[Student{id=13, name='wangwu', age=24}],
        // 25=[Student{id=14, name='zhaoliu', age=25}]}

        String str = studentList.stream().map(Student::getName)
                                .collect(Collectors.joining(","));
        System.out.println(str);  // zhangsan,lisi,wangwu,zhaoliu,liuqi
    }